//专门处理题库的业务逻辑
// 1. express 框架
const express = require('express');
const topicLibModel = require('../../model/topicLibModel');
// 导入jwt token工具
const JwtUtil = require('../../utils/jwt');
// 导入生成id的包
const { v4: uuidv4 } = require('uuid');
// 2.创建一个后台路由
const router = express.Router();

// 添加题库
router.post('/add', async (req, res) => {
    let { topic_lib_name, topic_count, topic_single_count, topic_multi_count, topic_judge_count, exam_time, exam_type, exam_limit, exam_fullcredit, exam_passline } = req.body;
    let token = req.headers.token;
    // 判断用户状态
    let jwt = new JwtUtil(token);
    // 返回一个对象（包含题库身份）
    let result = jwt.verifyToken();
    // 验通过执行下一步，否则就返回登陆信息不正确
    if (result == 'err') {
        // 提醒题库重新登录
        res.send({
            code: -1,
            msg: '登录已过期,请重新登录。'
        });
    } else {
        // 题库身份
        let user_id = result.data;
        // 题库标记 生成随机字符串
        let topic_lib_id = uuidv4();
        await topicLibModel.add(topic_lib_name, topic_count, topic_single_count, topic_multi_count, topic_judge_count, exam_time, exam_type, topic_lib_id, user_id, exam_limit, exam_fullcredit, exam_passline).then(content => {
            res.send(content)
        }).catch(
            err => {
                res.send(err);
            }
        )
    }

})

// 删除题库(题库自己删除)
router.post('/remove', async (req, res) => {
    let { topic_lib_id } = req.body;
    let token = req.headers.token;
    // 判断题库登录状态
    let jwt = new JwtUtil(token);
    // 返回一个对象（包含题库身份）
    let result = jwt.verifyToken();
    // 验通过执行下一步，否则就返回登陆信息不正确
    if (result == 'err') {
        // 提醒题库重新登录
        res.send({
            code: -1,
            msg: '登录已过期,请重新登录。'
        });
    } else {
        let user_id = result.data;
        await topicLibModel.remove(topic_lib_id, user_id).then(content => {
            res.send(content)
        }).catch(
            err => {
                res.send(err);
            }
        )
    }
})

// 删除题库（管理员删除）
router.post('/delete', async (req, res) => {
    let { topic_lib_id } = req.body;
    let token = req.headers.token;
    // 判断题库登录状态
    let jwt = new JwtUtil(token);
    // 返回一个对象（包含题库身份）
    let result = jwt.verifyToken();
    // 验通过执行下一步，否则就返回登陆信息不正确
    if (result == 'err') {
        // 提醒题库重新登录
        res.send({
            code: -1,
            msg: '登录已过期,请重新登录。'
        });
    } else {
        await topicLibModel.delete(topic_lib_id).then(content => {
            res.send(content)
        }).catch(
            err => {
                res.send(err);
            }
        )
    }
})

// 题库列表（管理员）
router.get('/list', async (req, res) => {
    let { page_num, page_size } = req.query;
    await topicLibModel.list(page_num, page_size).then(content => {
        res.send(content)
    }).catch(
        err => {
            res.send(err);
        }
    )
})

router.get('/list2', async (req, res) => {
    let token = req.headers.token;
    // 判断题库登录状态
    let jwt = new JwtUtil(token);
    // 返回一个对象（包含题库身份）
    let result = jwt.verifyToken();
    // 验通过执行下一步，否则就返回登陆信息不正确
    if (result == 'err') {
        // 提醒题库重新登录
        res.send({
            code: -1,
            msg: '登录已过期,请重新登录。'
        });
    } else {
        let user_id = result.data;
        await topicLibModel.list2(user_id).then(content => {
            res.send(content)
        }).catch(
            err => {
                res.send(err);
            }
        )
    }

})
// 题库列表（用户）
router.get('/list3', async (req, res) => {
    let { page_num, page_size } = req.query;
    let token = req.headers.token;
    // 判断题库登录状态
    let jwt = new JwtUtil(token);
    // 返回一个对象（包含题库身份）
    let result = jwt.verifyToken();
    // 验通过执行下一步，否则就返回登陆信息不正确
    if (result == 'err') {
        // 提醒题库重新登录
        res.send({
            code: -1,
            msg: '登录已过期,请重新登录。'
        });
    } else {
        let user_id = result.data;
        await topicLibModel.list3(page_num, page_size,user_id).then(content => {
            res.send(content)
        }).catch(
            err => {
                res.send(err);
            }
        )
    }

})
// 题库详情
router.get('/detail', async (req, res) => {
    let { topic_lib_id } = req.query;
    let token = req.headers.token;
    // 判断题库登录状态
    let jwt = new JwtUtil(token);
    // 返回一个对象（包含题库身份）
    let result = jwt.verifyToken();
    // 验通过执行下一步，否则就返回登陆信息不正确
    if (result == 'err') {
        // 提醒题库重新登录
        res.send({
            code: -1,
            msg: '登录已过期,请重新登录。'
        });
    } else {
        await topicLibModel.detail(topic_lib_id).then(content => {
            res.send(content)
        }).catch(
            err => {
                res.send(err);
            }
        )
    }
})

// 搜索题库
router.get('/search', async (req, res) => {
    let { keyword } = req.query;
    await topicLibModel.search(keyword).then(content => {
        res.send(content)
    }).catch(
        err => {
            res.send(err);
        }
    )
})

// 统计题库
router.get('/total', async (req, res) => {
    let token = req.headers.token;
    // 判断题库登录状态
    let jwt = new JwtUtil(token);
    // 返回一个对象（包含题库身份）
    let result = jwt.verifyToken();
    // 验通过执行下一步，否则就返回登陆信息不正确
    if (result == 'err') {
        // 提醒题库重新登录
        res.send({
            code: -1,
            msg: '登录已过期,请重新登录。'
        });
    } else {
        let user_id = result.data;
        await topicLibModel.total(user_id).then(content => {
            res.send(content)
        }).catch(
            err => {
                res.send(err);
            }
        )
    }

})

// 统计题库
router.get('/total2', async (req, res) => {
    let token = req.headers.token;
    // 判断题库登录状态
    let jwt = new JwtUtil(token);
    // 返回一个对象（包含题库身份）
    let result = jwt.verifyToken();
    // 验通过执行下一步，否则就返回登陆信息不正确
    if (result == 'err') {
        // 提醒题库重新登录
        res.send({
            code: -1,
            msg: '登录已过期,请重新登录。'
        });
    } else {
        let user_id = result.data;
        await topicLibModel.total2().then(content => {
            res.send(content)
        }).catch(
            err => {
                res.send(err);
            }
        )
    }

})

// 发布题库
router.get('/publish', async (req, res) => {
    let token = req.headers.token;
    let { topic_lib_id } = req.query;
    // 判断题库登录状态
    let jwt = new JwtUtil(token);
    // 返回一个对象（包含题库身份）
    let result = jwt.verifyToken();
    // 验通过执行下一步，否则就返回登陆信息不正确
    if (result == 'err') {
        // 提醒题库重新登录
        res.send({
            code: -1,
            msg: '登录已过期,请重新登录。'
        });
    } else {
        let user_id = result.data;
        await topicLibModel.publish(topic_lib_id).then(content => {
            res.send(content)
        }).catch(
            err => {
                res.send(err);
            }
        )
    }

})

// 获取已发布的题库
router.get('/get_publish', async (req, res) => {
    let token = req.headers.token;
    // 判断题库登录状态
    let jwt = new JwtUtil(token);
    // 返回一个对象（包含题库身份）
    let result = jwt.verifyToken();
    // 验通过执行下一步，否则就返回登陆信息不正确
    if (result == 'err') {
        // 提醒题库重新登录
        res.send({
            code: -1,
            msg: '登录已过期,请重新登录。'
        });
    } else {
        let user_id = result.data;
        await topicLibModel.get_publish(user_id).then(content => {
            res.send(content)
        }).catch(
            err => {
                res.send(err);
            }
        )
    }

})


// 导出题库路由
module.exports = router;